home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / demograph / windows.c < prev   
Encoding:
C/C++ Source or Header  |  1994-08-02  |  11.5 KB  |  482 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. #include "stdio.h"
  18. #include "gl.h"
  19. #include "device.h"
  20. #include "demograph.h"
  21.  
  22. extern CATEGORY *curcategory, *categoryroot;
  23. extern WINREC winrec;
  24. extern MACHREC machrec;
  25. extern int updatetext;
  26. extern DATA *curdata;
  27. extern int drawtype;
  28.  
  29. extern void (*drawmap)(float *data);
  30. extern void draw_slider(int minx, int miny, int maxx, int maxy, int fillcolor);
  31. extern void draw_line_map(float *data);
  32. extern void draw_solid_map(float *data);
  33. extern void draw_lighted_map(float *data);
  34.  
  35. Matrix idmatrix = { {1.0,0.0,0.0,0.0},
  36.             {0.0,1.0,0.0,0.0},
  37.             {0.0,0.0,1.0,0.0},
  38.             {0.0,0.0,0.0,1.0}};
  39.  
  40. float map_light[] ={LCOLOR, 1.0, 1.0, 1.0,
  41.             POSITION, -1.0, 2.0, 2.0, 0.0,
  42.             LMNULL};
  43.  
  44. int datamax, displaymax;
  45. int mainmenu, datamenu, displaymenu;
  46.  
  47. void initwin(void)
  48. {
  49.     void            init_cmRGB(void);
  50.     void            initmenus(void);
  51.  
  52.     keepaspect(WID, HT);
  53.     minsize(WID, HT);
  54.     winopen("demograph");
  55.     wintitle("demograph");
  56.  
  57.     mmode(MVIEWING);
  58.     loadmatrix(idmatrix);
  59.     subpixel(FALSE);
  60.  
  61.     qdevice(REDRAW);
  62.     qdevice(LEFTMOUSE);
  63.     qdevice(RIGHTMOUSE);
  64.     qdevice(MIDDLEMOUSE);
  65.     qdevice(WINQUIT);
  66.     qdevice(WINSHUT);
  67.  
  68.     qreset();
  69.     qenter(REDRAW, 0);
  70.  
  71.     doublebuffer();
  72.     gconfig();
  73.  
  74.     /* set color mode (RGB or cmap) in file init_cmRGB */
  75.     init_cmRGB();
  76.  
  77.     /* initialize drawing modes */
  78.     /* this must go after init_cmRGB as RGBmode() is set in init_cmRGB */
  79.  
  80.     if (machrec.RGB) {
  81.     lmdef(DEFMATERIAL, 1, 0, NULL);
  82.     lmdef(DEFLIGHT, 1, 0, map_light);
  83.     lmdef(DEFLMODEL, 1, 0, NULL);
  84.     }
  85.  
  86.     if (machrec.zbuffer) {
  87.     if (machrec.RGB) {
  88.         drawtype = LIGHTED;
  89.         drawmap = draw_lighted_map;
  90.     } else {
  91.         drawtype = SOLID;
  92.         drawmap = draw_solid_map;
  93.     }
  94.     } else {
  95.     drawtype = LINES;
  96.     drawmap = draw_line_map;
  97.     }
  98.  
  99.  
  100.     initmenus();
  101. }
  102.  
  103.  
  104. void redraw()
  105. {
  106.     long sizex, sizey;
  107.     register int s_frame_wid, m_frame_wid;
  108.     register WINREC *win;
  109.  
  110.     frontbuffer(TRUE);
  111.  
  112.     win = &winrec;    
  113.  
  114.     /* resize the window */
  115.     getsize(&sizex, &sizey);
  116.     getorigin(&win->orgx, &win->orgy);
  117.     viewport(0,sizex - 1, 0, sizey - 1);
  118.     ortho2(0.0,(float)(sizex - 1), 0.0, (float)(sizey - 1));
  119.  
  120.     if (drawtype == LIGHTED) {
  121.     lmbind(MATERIAL,1);
  122.     lmbind(LMODEL,1);
  123.     }
  124.  
  125.     setcolor(0,0,0);
  126.     clear();
  127.  
  128.     /* set window parameters and draw the borders */
  129.     win->scale = (float)sizex/WID;
  130.     win->sliderminx = win->sliderminy = 0;
  131.     win->slidermaxx = sizex - 1;
  132.     win->slidermaxy = (int)(SLIDERHT * win->scale + 0.5);
  133.     win->statminx = 0;
  134.     win->statmaxx = sizex - 1;
  135.     win->statminy = win->slidermaxy;
  136.     win->statmaxy = (int)((SLIDERHT + STATUSHT) * win->scale + 0.5);
  137.     win->mapminx = 0;
  138.     win->mapmaxx = sizex - 1;
  139.     win->mapminy = win->statmaxy;
  140.     win->mapmaxy = sizey - 1;
  141.  
  142.     s_frame_wid = (int)(S_FRAME_WID * win->scale + 0.5);
  143.     m_frame_wid = (int)(M_FRAME_WID * win->scale + 0.5);
  144.  
  145.     drawboarder(win->sliderminx, win->sliderminy, win->slidermaxx, 
  146.     win->slidermaxy,s_frame_wid);
  147.     drawboarder(win->mapminx, win->mapminy, win->mapmaxx, win->mapmaxy,
  148.     m_frame_wid);
  149.  
  150.     win->statminy += 2;
  151.     win->statmaxy -= 2;
  152.  
  153.     setcolor(0Xbb,0Xbb,0Xbb);
  154.     sboxfi(win->statminx, win->statminy, win->statmaxx, win->statmaxy);
  155.  
  156.     win->sliderminx += s_frame_wid;
  157.     win->sliderminy += s_frame_wid;
  158.     win->slidermaxx -= s_frame_wid;
  159.     win->slidermaxy -= s_frame_wid;
  160.  
  161.     win->mapminx += m_frame_wid;
  162.     win->mapminy += m_frame_wid;
  163.     win->mapmaxx -= m_frame_wid;
  164.     win->mapmaxy -= m_frame_wid;
  165.  
  166.     win->sliderwid = (int)(SLIDERWID * win->scale / 2.0 + 0.5);
  167.  
  168.  
  169.     setcolor(0xbb,0xbb,0xbb);
  170.     sboxfi(win->sliderminx, win->sliderminy, win->slidermaxx, win->slidermaxy);
  171.  
  172.     setcolor(0,0,0);
  173.     sboxfi(win->mapminx, win->mapminy, win->mapmaxx, win->mapmaxy);
  174.     sboxi(win->sliderminx, win->sliderminy, win->slidermaxx, win->slidermaxy);
  175.  
  176.     win->sliderminx++;
  177.     win->sliderminy++;
  178.     win->slidermaxx--;
  179.     win->slidermaxy--;
  180.     win->mapminx++;
  181.     win->mapminy++;
  182.     win->mapmaxx--;
  183.     win->mapmaxy--;
  184.  
  185.     init_text();
  186.     writetitle(curcategory->title);
  187.     if (winrec.fps) {
  188.     writefps(winrec.lasttime);
  189.     }
  190.  
  191.     frontbuffer(FALSE);
  192.     drawaction();
  193. }
  194.  
  195. drawaction()
  196. {
  197.     int x;
  198.     int wid = winrec.sliderwid;
  199.     int sminx = winrec.sliderminx;
  200.     int smaxx = winrec.slidermaxx;
  201.     int sminy = winrec.sliderminy;
  202.     int smaxy = winrec.slidermaxy;
  203.     int minval = sminx + wid;
  204.     int index;
  205.  
  206.     float range = (smaxx - wid) - minval;
  207.  
  208.     x = (winrec.slideroldx * (range) + 0.5) + sminx + wid;
  209.     if (x < minval) {
  210.     x = minval;
  211.     winrec.slideroldx = (float)(x-sminx-wid) / (float)(range);
  212.     }
  213.     draw_slider(x - wid,sminy, x + wid,smaxy,0xbb);
  214.  
  215.     index = (int)((float)((x-minval)*(MAXDATA-1))/range + 0.5);
  216.     curdata = &curcategory->dataarray[index];
  217.     writesliderdate(curdata->date,(float)x);
  218.     (*drawmap)(curdata->data);
  219. /*    if(updatetext) {
  220. /*    displaydata(curdata->data);
  221. /*    }
  222. */
  223.     swapbuffers();
  224.     setcolor(0xbb, 0xbb, 0xbb);
  225.     sboxfi(x - wid, sminy, x + wid, smaxy);
  226. }
  227.  
  228.  
  229.  
  230. /****************************************************************************
  231. Needs to be rewritten to be color dominanat instead of position dominant.
  232. We use rectfi here because Personal IRIS does not do pattern masked lines.
  233. Not particularly critical for speed - only gets drawn once.
  234. ****************************************************************************/
  235. /* draws a boarder mimmicking the news "shaded" window 9 pixels wide.  This
  236.    routine expects a 1 to 1 scale with the screen.
  237. */
  238. int drawboarder(xmin, ymin, xmax, ymax, width)
  239. /* these must be scaled to screen coordinates */
  240. int xmin, ymin, xmax, ymax, width;
  241. {
  242.     int             tmp;
  243.  
  244.     /* force minimum width */
  245.     if (width < 7.0)
  246.     width = 7.0;
  247.  
  248.     /* fill in the background sbox does not work here (a23) */
  249.     tmp = width - 1;
  250.  
  251.     setcolor(0xbb, 0xbb, 0xbb);
  252.     sboxfi(xmin, ymin, xmax, ymin + tmp);    /* bottom */
  253.     sboxfi(xmin, ymin + tmp, xmin + tmp, ymax - tmp);    /* left */
  254.     sboxfi(xmax - tmp, ymin + tmp, xmax, ymax - tmp);    /* right */
  255.     sboxfi(xmin, ymax - tmp, xmax, ymax);    /* top */
  256.  
  257.  
  258.     /* draw top highlight and move in one more pixel on the top */
  259.     setcolor(0xff, 0xff, 0xff);
  260.     sboxfi(xmin, ymax, xmax, ymax);                /* outside */
  261.     sboxfi(xmin + width, ymin + tmp, xmax - width, ymin + tmp);/* inside */
  262.     ymax--;
  263.  
  264.     tmp = ymin + 1;
  265.     setcolor(0xee, 0xee, 0xee);
  266.     sboxfi(xmin, tmp, xmin, ymax);                /* outside */
  267.     sboxfi(xmin, ymax, xmax, ymax);
  268.     sboxfi(xmax, ymax, xmax, tmp);
  269.     xmin++;
  270.     xmax--;
  271.     ymax--;
  272.  
  273.     tmp = width - 2;
  274.     setcolor(0xee, 0xee, 0xee);
  275.     sboxfi(xmin + tmp, ymax - tmp, xmin + tmp, ymin + tmp);    /* inside */
  276.     sboxfi(xmin + tmp, ymin + tmp, xmax - tmp, ymin + tmp);
  277.     sboxfi(xmax - tmp, ymin + tmp, xmax - tmp, ymax - tmp);
  278.  
  279.     tmp = ymin + 2;
  280.     setcolor(0xdd, 0xdd, 0xdd);
  281.     sboxfi(xmin, tmp, xmin, ymax);                /* outside */
  282.     sboxfi(xmin, ymax, xmax, ymax);
  283.     sboxfi(xmax, ymax, xmax, tmp);
  284.     tmp = width - 3;
  285.  
  286.     setcolor(0xdd, 0xdd, 0xdd);
  287.     sboxfi(xmin + tmp, ymax - tmp, xmin + tmp, ymin + tmp);    /* inside */
  288.     sboxfi(xmin + tmp, ymin + tmp, xmax - tmp, ymin + tmp);
  289.     sboxfi(xmax - tmp, ymin + tmp, xmax - tmp, ymax - tmp);
  290.  
  291.     setcolor(0x66, 0x66, 0x66);
  292.     sboxfi(xmin, ymin, xmax, ymin);                /* outside */
  293.     xmin++;
  294.     ymin++;
  295.     xmax--;
  296.  
  297.  
  298.     ymax -= width - 3;
  299.  
  300.     tmp = width - 2;
  301.     setcolor(0x66, 0x66, 0x66);
  302.     sboxfi(xmin + tmp, ymax, xmax - tmp, ymax);        /* inside */
  303.     ymax++;
  304.  
  305.     setcolor(0x88, 0x88, 0x88);
  306.     sboxfi(xmin, ymin, xmax, ymin);
  307.     xmin++;
  308.  
  309.     tmp = width - 3;
  310.     setcolor(0x88, 0x88, 0x88);
  311.     sboxfi(xmin + tmp, ymax, xmax - tmp, ymax);        /* inside */
  312.     ymax++;
  313.  
  314.     setcolor(0xaa, 0xaa, 0xaa);
  315.     sboxfi(xmin, ymin, xmax, ymin);                /* outside */
  316.  
  317.     tmp = width - 4;
  318.     setcolor(0xaa, 0xaa, 0xaa);
  319.     sboxfi(xmin + tmp, ymax, xmax - tmp, ymax);        /* inside */
  320.     return (width);
  321. }
  322.  
  323.  
  324. void qprocess(dev,qval)
  325. int dev;
  326. short qval;
  327. {
  328.     long x, y;
  329.     int menuret;
  330.     int i;
  331.  
  332.     switch (dev) {
  333.     case LEFTMOUSE:
  334.         if (qval) {
  335.         x = getvaluator(MOUSEX) - winrec.orgx;
  336.         y = getvaluator(MOUSEY) - winrec.orgy;
  337.         if (getview(x,y) == SLIDERPORT) {
  338.             updateslider();
  339.         } else {
  340.             flipmap(TRANSXY);
  341.         }
  342.         }
  343.         break;
  344.     case MIDDLEMOUSE:
  345.         if(qval) {
  346.         x = getvaluator(MOUSEX) - winrec.orgx;
  347.         y = getvaluator(MOUSEY) - winrec.orgy;
  348.         if (getview(x,y) == MAPPORT) {
  349.             flipmap(SPIN);
  350.         }
  351.         }
  352.         break;
  353.     case RIGHTMOUSE:
  354.         menuret = dopup(mainmenu);
  355.         if (menuret < 1) {
  356.         break;
  357.         }
  358.         if (menuret <= datamax) {
  359.         curcategory = categoryroot;
  360.         for (i = 1; i < menuret; i++) {
  361.             curcategory = curcategory->next;
  362.         }
  363.         /* erase the status window */
  364.         frontbuffer(TRUE);
  365.         setcolor(0xbb,0xbb,0xbb);
  366.         sboxfi(winrec.statminx,winrec.statminy,
  367.             winrec.statmaxx,winrec.statmaxy);
  368.         init_text();
  369.         writetitle(curcategory->title);
  370.         writefps(0.0);
  371.  
  372.         /* drawaction will update the frames_per_second */
  373.         frontbuffer(FALSE);
  374.         drawaction();
  375.         } else if (menuret <= displaymax) {
  376.         /* drawtype: 0=lines, 1=tops, 2=solid, 3=lighted */
  377.         drawtype = menuret - (datamax+1);
  378.         switch (drawtype) {
  379.             case LINES:
  380.             drawtype = LINES;
  381.             drawmap = draw_line_map;
  382.             break;
  383.             case TOPS:
  384.             drawtype = TOPS;
  385.             drawmap = draw_line_map;
  386.             break;
  387.             case SOLID:
  388.             drawtype = SOLID;
  389.             drawmap = draw_solid_map;
  390.             break;
  391.             case LIGHTED:
  392.             drawtype = LIGHTED;
  393.             drawmap = draw_lighted_map;
  394.             break;
  395.             default:
  396.             fprintf(stderr,"unrecognized drawing type\n");
  397.             break;
  398.         }
  399.         drawaction();
  400.         } else {
  401.         exit(0);
  402.         }
  403.         break;
  404.     case REDRAW:
  405.         redraw();
  406.         break;
  407.     case WINQUIT:
  408.     case WINSHUT:
  409.         /* if text - shut down text window */
  410.         exit(0);
  411.         break;
  412.     }
  413. }
  414.  
  415. int getview(x,y)
  416. long x, y;
  417. {
  418.     if (x < winrec.slidermaxx && x > winrec.sliderminx && y < winrec.slidermaxy
  419.     && y > winrec.sliderminy) {
  420.         return(SLIDERPORT);
  421.     }
  422.  
  423.     if (x < winrec.mapmaxx && x > winrec.mapminx && y < winrec.mapmaxy
  424.     && y > winrec.mapminy) {
  425.         return(MAPPORT);
  426.     }
  427.     return(NOPORT);
  428. }
  429.  
  430.  
  431. void initmenus()
  432. {
  433.     char menustr[256];
  434.     int n;
  435.     CATEGORY *tmpcategory;
  436.  
  437.     tmpcategory = categoryroot;
  438.     n = 0;
  439.     
  440.     /* make submenu to pick data type */
  441.     datamenu = newpup();
  442.     while (tmpcategory != NULL) {
  443.     n++;
  444.     sprintf(menustr,"%s %%x%d",tmpcategory->title,n);
  445.     addtopup(datamenu,menustr);
  446.     tmpcategory = tmpcategory->next;
  447.     }
  448.  
  449.     datamax = n;
  450.  
  451.     /* make display menu */
  452.     n++;
  453.     displaymenu = newpup();
  454.     sprintf(menustr,"Lines %%x%d",n);
  455.     addtopup(displaymenu,menustr);
  456.  
  457.     if (machrec.zbuffer) {
  458.     n++;
  459.     sprintf(menustr,"Tops %%x%d",n);
  460.     addtopup(displaymenu,menustr);
  461.  
  462.     n++;
  463.     sprintf(menustr,"Solids %%x%d",n);
  464.     addtopup(displaymenu,menustr);
  465.  
  466.     if (machrec.RGB) {
  467.         n++;
  468.         sprintf(menustr,"Lighted %%x%d",n);
  469.         addtopup(displaymenu,
  470. menustr);
  471.         n++;
  472.     }
  473.     }
  474.     displaymax = n;
  475.  
  476.     sprintf(menustr,
  477.     "Demographics %%t|Data %%x%d%%m|Display %%x%d%%m|Exit %%x%d",
  478.         n+1,n+2,n+3);
  479.  
  480.     mainmenu = defpup(menustr,datamenu,displaymenu);
  481. }
  482.